// @title 后端API系统
// @version 1.0
// @description Go语言后端API系统，支持前台用户和后台管理员双重认证
// @termsOfService http://swagger.io/terms/

// @contact.name API Support
// @contact.url http://www.swagger.io/support
// @contact.email support@swagger.io

// @license.name Apache 2.0
// @license.url http://www.apache.org/licenses/LICENSE-2.0.html

// @host localhost:8080
// @BasePath /api

// @securityDefinitions.apikey FrontendAuth
// @in header
// @name Authorization
// @description 前台用户JWT认证，格式: Bearer {token}

// @securityDefinitions.apikey AdminAuth
// @in header
// @name Authorization
// @description 后台管理员JWT认证，格式: Bearer {token}

package main

import (
	"fmt"
	"log"
	"net/http"
	"os"
	"os/signal"
	"syscall"
	"time"

	"backend-api/config"
	"backend-api/docs"
	"backend-api/internal/handlers"
	"backend-api/internal/middleware"
	"backend-api/pkg/database"

	"github.com/gin-gonic/gin"
	"github.com/sirupsen/logrus"
	ginSwagger "github.com/swaggo/gin-swagger"
	swaggerFiles "github.com/swaggo/files"
)

func main() {
	// 加载配置
	cfg, err := config.LoadConfig("config/config.yaml")
	if err != nil {
		log.Fatalf("加载配置文件失败: %v", err)
	}

	// 设置日志级别
	setupLogger(cfg.Log.Level)

	// 设置Gin模式
	gin.SetMode(cfg.Server.Mode)

	// 初始化数据库
	if err := database.InitDatabase(&cfg.Database); err != nil {
		logrus.Fatalf("初始化数据库失败: %v", err)
	}

	// 初始化Redis
	if err := database.InitRedis(&cfg.Redis); err != nil {
		logrus.Fatalf("初始化Redis失败: %v", err)
	}

	// 自动迁移数据库表
	if err := database.AutoMigrate(); err != nil {
		logrus.Fatalf("数据库表迁移失败: %v", err)
	}

	// 创建Gin引擎
	r := gin.New()

	// 添加中间件
	r.Use(gin.Logger())
	r.Use(gin.Recovery())
	r.Use(middleware.CORSMiddleware())

	// Swagger文档路由
	docs.SwaggerInfo.Host = fmt.Sprintf("localhost:%d", cfg.Server.Port)
	r.GET("/swagger/*any", ginSwagger.WrapHandler(swaggerFiles.Handler))

	// 健康检查接口
	// @Summary 健康检查
	// @Description 检查服务运行状态
	// @Tags 系统
	// @Accept json
	// @Produce json
	// @Success 200 {object} map[string]interface{} "服务运行正常"
	// @Router /health [get]
	r.GET("/health", func(c *gin.Context) {
		c.JSON(http.StatusOK, gin.H{
			"code":    200,
			"message": "服务运行正常",
			"data": gin.H{
				"status":    "healthy",
				"timestamp": time.Now().Unix(),
			},
		})
	})

	// API路由组
	api := r.Group("/api")
	{
		// 前台API路由
		frontend := api.Group("/frontend")
		{
			// 初始化用户处理器
			userHandler := handlers.NewUserHandler()

			// 公开接口（无需认证）
			frontend.POST("/register", userHandler.Register)
			frontend.POST("/login", userHandler.Login)

			// 需要认证的接口
			auth := frontend.Group("/")
			auth.Use(middleware.FrontendAuthMiddleware())
			{
				auth.GET("/profile", userHandler.GetProfile)
				auth.PUT("/profile", userHandler.UpdateProfile)
				auth.POST("/logout", userHandler.Logout)
			}
		}

		// 后台API路由
		admin := api.Group("/admin")
		{
			// 初始化管理员处理器
			adminHandler := handlers.NewAdminHandler()

			// 公开接口（无需认证）
			admin.POST("/login", adminHandler.Login)

			// 需要认证的接口
			auth := admin.Group("/")
			auth.Use(middleware.AdminAuthMiddleware())
			{
				// 管理员相关
				auth.GET("/profile", adminHandler.GetProfile)
				auth.POST("/logout", adminHandler.Logout)

				// 用户管理
				users := auth.Group("/users")
				{
					users.GET("/", adminHandler.GetUserList)
					users.GET("/:id", adminHandler.GetUserByID)
					users.PUT("/:id/status", adminHandler.UpdateUserStatus)
					users.DELETE("/:id", adminHandler.DeleteUser)
				}
			}
		}
	}

	// 启动服务器
	addr := fmt.Sprintf(":%d", cfg.Server.Port)
	logrus.Infof("服务器启动在端口 %d", cfg.Server.Port)

	// 创建HTTP服务器
	srv := &http.Server{
		Addr:         addr,
		Handler:      r,
		ReadTimeout:  cfg.Server.ReadTimeout,
		WriteTimeout: cfg.Server.WriteTimeout,
	}

	// 在goroutine中启动服务器
	go func() {
		if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
			logrus.Fatalf("服务器启动失败: %v", err)
		}
	}()

	// 等待中断信号以优雅地关闭服务器
	quit := make(chan os.Signal, 1)
	signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
	<-quit
	logrus.Info("正在关闭服务器...")

	// 关闭数据库连接
	if err := database.CloseDatabase(); err != nil {
		logrus.Errorf("关闭数据库连接失败: %v", err)
	}

	// 关闭Redis连接
	if err := database.CloseRedis(); err != nil {
		logrus.Errorf("关闭Redis连接失败: %v", err)
	}

	logrus.Info("服务器已关闭")
}

// setupLogger 设置日志配置
func setupLogger(level string) {
	// 设置日志级别
	switch level {
	case "debug":
		logrus.SetLevel(logrus.DebugLevel)
	case "info":
		logrus.SetLevel(logrus.InfoLevel)
	case "warn":
		logrus.SetLevel(logrus.WarnLevel)
	case "error":
		logrus.SetLevel(logrus.ErrorLevel)
	default:
		logrus.SetLevel(logrus.InfoLevel)
	}

	// 设置日志格式
	logrus.SetFormatter(&logrus.JSONFormatter{
		TimestampFormat: "2006-01-02 15:04:05",
	})
}